package util;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

import twitter4j.*;
import twitter4j.auth.AccessToken;
import twitter4j.auth.RequestToken;

/**
 * Interface de comunicacao com o Twitter
 * @author Delano Oliveira, Izabela Melo, Nata Venancio e Savyo Igor
 *
 */
public class InterfaceTwitter {
	
	private final String CONSUME_KEY  = "ZWNcHxzgJccFV2aiJxRqIg";
	private final String CONSUME_SECRET = "XyWtqyxHxOIVV2tGPjRWHRXr6J4jCtFPlynvoylwXQ";
	
	private static InterfaceTwitter singleton;
	private static Twitter twitter;
	private RequestToken requestToken;
	private AccessToken accessToken = null;
	
	//Mapa com o login de quem o usuario mencionou e quantas vezes mencionou
	private static Map<String, Integer> mapaDeMencoesFeitas = new HashMap<String, Integer>();
	
	//Mapa com o login de quem mencionou o usuario e quantas vezes mencionou
	private Map<String, Integer> mapaDeMencoesRecebidas = new HashMap<String, Integer>();
	
	private Map<String, Integer> mapaDeHashTags = new HashMap<String, Integer>();
	
	//-----------------------------------------------------------------------
	
	//Mapa com o login de quem o usuario mencionou e um array com as datas das mencoes
	private Map<String, Date[]> mapaMencoesFeitasDatas = new HashMap<String, Date[]>();
	
	//Mapa com o login de quem mencionou o usuario e um array com as datas das mencoes
	private Map<String, Date[]> mapaMencoesRecebidasDatas = new HashMap<String, Date[]>();
	
	//Mapa com as tags do usuario e um array com as datas das mencoes
	private Map<String, Date[]> mapaTagDatas = new HashMap<String, Date[]>();
	
	
	
	/**
	 * Construtor privado da classe de comunicacao entre os
	 * componentes da aplicacao e o Twitter
	 * @throws TwitterException
	 * @throws IOException
	 */
	private InterfaceTwitter() throws TwitterException, IOException {
		twitter = new TwitterFactory().getInstance();
	    
	}
	
	/**
	 * Metodo que permite que a nossa aplicacao tenha acesso aos dados do twitter.
	 * Esse metodo deve vir logo apos a criacao da classe interfaceTwitter
	 */
	public void setAuthConsumerTwitter(){
		twitter.setOAuthConsumer(CONSUME_KEY, CONSUME_SECRET);
	}
	
	/**
	 * Recupera o Request (necessario para capturar o AccessToken)
	 * Deve vir logo apos permitir o acesso aos dados do twitter
	 * @throws TwitterException
	 */
	public void recuperaRequest() throws TwitterException{
		this.requestToken = twitter.getOAuthRequestToken();
	}
	
	/**
	 * Metodo para gerar a URL, onde o usuario de um twitter vai 
	 * autorizar a nossa aplicacao a ter acesso aos dados do twitter dele.
	 * @return
	 */
	public String geraURL(){
		return requestToken.getAuthorizationURL();
	}
	
	/**
	 * Metodo que retorna o AccessToken. Ele eh necessario
	 * para realizar a autenticacao da aplicacao no twitter
	 * @param pin (necessario para recuperar o accessToken)
	 * @return
	 */
	public AccessToken returnAccess(String pin){
		  try{
	         if(pin.length() > 0){
	           accessToken = twitter.getOAuthAccessToken(requestToken, pin);
	         }else{
	           accessToken = twitter.getOAuthAccessToken();
	         }
	      } catch (TwitterException te) {
	        if(401 == te.getStatusCode()){
	          System.out.println("Unable to get the access token.");
	        }else{
	          te.printStackTrace();
	        }
	      }
	      return accessToken;
	}
	
	/**
	 * Realiza a autenticacao no twitter
	 */
	public void autentica(){
		twitter.setOAuthAccessToken(accessToken);
	}
	
	/**
	 * Implementa o padrao Singleton, pois soh pode existir 
	 * uma interface para manipular o Twitter
	 * @param login
	 * @return
	 * @throws IOException 
	 */
	public static InterfaceTwitter getInstance(){
		if(singleton == null){
			try {
				return new InterfaceTwitter();
			} catch (TwitterException e) {
				System.err.println("Problemas na autenticacao do Twitter: " + e.getMessage());
			} catch (IOException e) {
				System.err.println(e.getMessage());
			}
		}
		return singleton;
	}


	public void setTwitter(Twitter twitter) {
		this.twitter = twitter;
	}

	public Twitter getTwitter() {
		return twitter;
	}

	public Object getAccessToken() {
		return accessToken;
	}
	
	public String getLoginUsuario() throws IllegalStateException, TwitterException{
		return this.twitter.getScreenName();
	}
	
	/**
	 * Retorna uma lista com as informacoes do usuario logado
	 * Formato da lista: [login, nome, descricao, localizacao, numero de followers, numero de following, id, 
	 *                    url da imagem, url do perfil, boolean se eh perfil protegido]
	 * @return
	 * @throws IllegalStateException
	 * @throws TwitterException
	 */
	public ArrayList<Object> getInformacoesUsuario() throws IllegalStateException, TwitterException{
		User user = twitter.showUser(twitter.getScreenName());
		ArrayList<Object> info = new ArrayList<Object>();
		info.add(user.getScreenName());
		info.add(user.getName());
		info.add(user.getDescription());
		info.add(user.getLocation());
		info.add(user.getFollowersCount());
		info.add(user.getFriendsCount());
		info.add(user.getId());
		info.add(user.getProfileImageURL());
		info.add(user.getURL());
		info.add(user.isProtected());
		
		return info;
	}
	
	/**
	 * Retorna uma lista com as informacoes de qualquer usuario passado como parametro
	 * Formato da lista: [login, nome, descricao, localizacao, numero de followers, numero de following, id, 
	 *                    url da imagem, url do perfil, boolean se eh perfil protegido]
	 * @param login
	 * @return
	 * @throws IllegalStateException
	 * @throws TwitterException
	 */
	public ArrayList<Object> getInformacoesUsuarioQualquer(String login) throws IllegalStateException, TwitterException{
		User user = twitter.showUser(login);
		ArrayList<Object> info = new ArrayList<Object>();
		info.add(user.getScreenName());
		info.add(user.getName());
		info.add(user.getDescription());
		info.add(user.getLocation());
		info.add(user.getFollowersCount());
		info.add(user.getFriendsCount());
		info.add(user.getId());
		info.add(user.getProfileImageURL());
		info.add(user.getURL());
		info.add(user.isProtected());
		
		return info;
	}
	
	/**
	 * Retorna uma lista com os logins das pessoas que o usuario segue
	 * @return
	 * @throws IllegalStateException
	 * @throws TwitterException
	 */
	public ArrayList<String> getFollowing() throws IllegalStateException, TwitterException{
		PagableResponseList<User> timeline = twitter.getFriendsStatuses(-1);
		ArrayList<String> logins = new ArrayList<String>();
		long cursor;
		for (User u : timeline) {
			logins.add(u.getScreenName());
		}
		while(timeline.hasNext()){
			cursor = timeline.getNextCursor();
			timeline = twitter.getFriendsStatuses(cursor);
			for (User u : timeline) {
				logins.add(u.getScreenName());
			}
			
			
		}
		return logins;
	}
	
	/**
	 * Retorna a lista de followers do usuario autenticado
	 * @return
	 * @throws IllegalStateException
	 * @throws TwitterException
	 */
	public ArrayList<String> getFollowers() throws IllegalStateException, TwitterException{
		PagableResponseList<User> timeline = twitter.getFollowersStatuses(-1);
		ArrayList<String> logins = new ArrayList<String>();
		long cursor;
		for (User u : timeline) {
			logins.add(u.getScreenName());
		}
		while(timeline.hasNext()){
			cursor = timeline.getNextCursor();
			timeline = twitter.getFriendsStatuses(cursor);
			for (User u : timeline) {
				logins.add(u.getScreenName());
			}
			
		}
		return logins;
	}
	
	/**
	 * Retorna os ultimos tweets do usuario logado
	 * @return
	 * @throws TwitterException
	 */
	private ResponseList<Status> getMentionsUser() throws TwitterException{
		ResponseList<Status> a = twitter.getUserTimeline();
		//System.out.println("Numero de tweets recuperados do usuario: " + a.size());
        return a;
	}
	

	/**
	 * Calcula mapa com chaves = login dos usuarios que foram mencionados pelo usuario logado
	 * valor = quantas vezes o usuario foi mencionado pelo usuario logado.
	 * @return
	 * @throws TwitterException
	 */
	public void calculaMapaMencoesFeitas() throws TwitterException{
		ResponseList<Status> mencoes = getMentionsUser();
		for (Status status : mencoes) {
			//System.out.println(status.toString());
			String to = status.getInReplyToScreenName();
			String from = status.getUser().getScreenName();
			if(to != null){
				adicionaAoMapaDeMencoesFeitas(to);
			}
			if(from != null){
				adicionaAoMapaDeMencoesFeitas(from);
			}
			ArrayList<String> semNull = procureMencoes(status.getText(), to, from);
			for (String string : semNull) {
				adicionaAoMapaDeMencoesFeitas(string);
			}
		}
	}
	
	/**
	 * Retorna o mapa calculado em calculaMapaMencoesFeitas
	 * @return
	 */
	public HashMap<String, Integer> retornaMapaMencoesFeitas(){
		return (HashMap<String, Integer>) mapaDeMencoesFeitas;
	}
	
	/**
	 * Metodo auxiliar para o metodo retornaMapaMencoesFeitas()
	 * Para evitar repeticoes e deixar o codigo mais enxuto
	 * @param string
	 * @throws IllegalStateException
	 * @throws TwitterException
	 */
	private void adicionaAoMapaDeMencoesFeitas(String string) throws IllegalStateException, TwitterException{
		if(!string.equals(twitter.getScreenName())){
			if(!mapaDeMencoesFeitas.containsKey(string)){
				mapaDeMencoesFeitas.put(string , 1);
			}else{
				mapaDeMencoesFeitas.put(string, (mapaDeMencoesFeitas.get(string) + 1));
			}
		}
	}
	
	/**
	 * Procura mencoes a outros usuarios no meio do tweet da pessoa autenticada ao sistema
	 * Metodo auxiliar para o metodo retornaMapaMencoesFeitas()
	 * @param text
	 * @param to
	 * @param from
	 * @return
	 */
	private ArrayList<String> procureMencoes(String text, String to, String from) {
		ArrayList<String> mencoes = new ArrayList<String>();
		String[] m = text.split(" ");
		for (String string : m) {
			if(string.length() > 0){
				if(String.valueOf((string.charAt(0))).equals("@") && !(string.substring(1).replace(":", "")).equals(to) && !(string.substring(1).replace(":", "")).equals(from)){
					mencoes.add(string.substring(1).replace(":", ""));
				}
			}
			
		}
		return mencoes;
	}


	/**
	 * Retorna a lista de mencoes sobre o usuario logado
	 * @return
	 * @throws TwitterException
	 */
	private ResponseList<Status> getMentionsAboutUser() throws TwitterException{
		ResponseList<Status> a = twitter.getMentions();
		//System.out.println("Numero de mencoes que fizeram ao usuario: " + a.size());
        return a;
	}
	
	/**
	 * Calcula o mapa com chaves = login dos usuarios que mencionaram o usuario logado
	 * valor = quantas vezes o usuario mencionou o usuario logado.
	 * @return
	 * @throws TwitterException
	 */
	public void calculaMapaMencoesRecebidas() throws TwitterException{
		ResponseList<Status> mencoes = getMentionsAboutUser();
		for (Status status : mencoes) {
			//System.out.println("  ->  "+status.toString());
			String to = status.getInReplyToScreenName();
			String from = status.getUser().getScreenName();
			if(!from.equals(twitter.getScreenName())){
				if(!mapaDeMencoesRecebidas.containsKey(from)){
					mapaDeMencoesRecebidas.put(from , 1);
				}else{
					mapaDeMencoesRecebidas.put(from, (mapaDeMencoesRecebidas.get(from) + 1));
				}	
			}
			
			if(to != null){
				if(!to.equals(twitter.getScreenName())){
					if(!mapaDeMencoesRecebidas.containsKey(to)){
						mapaDeMencoesRecebidas.put(to , 1);
					}else{
						mapaDeMencoesRecebidas.put(to, (mapaDeMencoesRecebidas.get(to) + 1));
					}
				}	
			}
			
		}
		
	}
	
	/**
	 * Retorna o mapa calculado em calculaMapaMencoesRecebidas()
	 * @return
	 */
	public HashMap<String, Integer> retornaMapaMencoesRecebidas(){
		return (HashMap<String, Integer>) mapaDeMencoesRecebidas;
	}
	
	/**
	 * Metodo que vai atualizar o mapa de hashtag do usuario autenticado
	 * @throws TwitterException
	 */
	public void calculaMapaHashTag() throws TwitterException{
		ResponseList<Status> a = getMentionsUser();
		for (Status status : a) {
			ArrayList<String> tags = capturaTags(status.getText());
			for (String string : tags) {
				adicionaAoMapaHashTag(string);
			}
		}
	}

	/**
	 * Metodo auxiliar do calculaMapaHashTag()
	 * Captura as tags em um tweet
	 * @param text
	 * @return
	 */
	private ArrayList<String> capturaTags(String text) {
		ArrayList<String> tags = new ArrayList<String>();
		String[] m = text.split(" ");
		for (String string : m) {
			if(string.length() > 0){
				if(String.valueOf((string.charAt(0))).equals("#")){
					tags.add(string);
				}
			}
		}
		return tags;
	}
	
	/**
	 * Adiona as tags usadas mais recentemente pelo usuario autenticado no sistema
	 * Metodo auxiliar do calculaMapaHashTag()
	 * @param string
	 */
	private void adicionaAoMapaHashTag(String string) {
		if(!mapaDeHashTags.containsKey(string)){
			mapaDeHashTags.put(string , 1);
		}else{
			mapaDeHashTags.put(string, (mapaDeHashTags.get(string) + 1));
		}
		
	}

	
	/**
	 * Retorna o mapa com as hashtags como chave e a quantidade de vezes que foram usadas como valor
	 * @return
	 */
	public HashMap<String, Integer> retorneMapaHashTag(){
		return (HashMap<String, Integer>) mapaDeHashTags;
	}
	
	//---------------------------------------------------------------------------------------------------
	//   METODOS COM DATAS
	//---------------------------------------------------------------------------------------------------
	
	/**
	 * Povoa mapa de mencoes feita pelo usuario logado e um array com as datas das mencoes
	 * @throws TwitterException
	 */
	public void calculaMapaMencoesFeitasComData() throws TwitterException{
		ResponseList<Status> mencoes = getMentionsUser();
		for (Status status : mencoes) {
			Date data = status.getCreatedAt();
			String to = status.getInReplyToScreenName();
			String from = status.getUser().getScreenName();
			if(to != null){
				adicionaAoMapaDeMencoesComDatas(to, data);
			}
			if(from != null){
				adicionaAoMapaDeMencoesComDatas(from, data);
			}
			ArrayList<String> semNull = procureMencoes(status.getText(), to, from);
			for (String string : semNull) {
				adicionaAoMapaDeMencoesComDatas(string, data);
			}
		}
	}
	
	/**
	 * Metodo auxiliar de calculaMapaMencoesFeitasComData()
	 * @param string
	 * @param data
	 * @throws IllegalStateException
	 * @throws TwitterException
	 */
	private void adicionaAoMapaDeMencoesComDatas(String string, Date data) throws IllegalStateException, TwitterException {
		if(!string.equals(twitter.getScreenName())){
			if(!mapaMencoesFeitasDatas.containsKey(string)){
				Date[] d = new Date[1];
				d[0] = data;
				mapaMencoesFeitasDatas.put(string , d);
			}else{
				Date[] d = mapaMencoesFeitasDatas.get(string);
				Date[] aux = new Date[d.length + 1];
				for (int i = 0; i < d.length; i++) {
					aux[i] = d[i];
				}
				aux[d.length] = data;
				mapaMencoesFeitasDatas.put(string, aux);
			}
		}
		
	}
	
	/**
	 * Retorna o mapa com o login do usuario mencionado pelo usuario autenticado com as datas das mencoes
	 * @return
	 */
	public HashMap<String, Date[]> retornaMapaMencoesFeitasDatas(){
		return (HashMap<String, Date[]>) mapaMencoesFeitasDatas;
	}

	
	/**
	 * Calcula o mapa das mencoes que o usuario autenticado recebeu com login como chave e lista de datas como valores
	 * @throws TwitterException
	 */
	public void calculaMapaMencoesRecebidasComDatas() throws TwitterException{
		ResponseList<Status> mencoes = getMentionsAboutUser();
		for (Status status : mencoes) {
			String to = status.getInReplyToScreenName();
			String from = status.getUser().getScreenName();
			Date data = status.getCreatedAt();
			if(!from.equals(twitter.getScreenName())){
				if(!mapaMencoesRecebidasDatas.containsKey(from)){
					Date[] d = new Date[1];
					d[0] = data;
					mapaMencoesRecebidasDatas.put(from , d);
				}else{
					Date[] d = mapaMencoesRecebidasDatas.get(from);
					Date[] aux = new Date[d.length + 1];
					for (int i = 0; i < d.length; i++) {
						aux[i] = d[i];
					}
					aux[d.length] = data;
					mapaMencoesRecebidasDatas.put(from, aux);
				}
					
			}
			if(to != null){
				if(!to.equals(twitter.getScreenName())){
					if(!mapaMencoesRecebidasDatas.containsKey(to)){
						Date[] d = new Date[1];
						d[0] = data;
						mapaMencoesRecebidasDatas.put(to , d);
					}else{
						Date[] d = mapaMencoesRecebidasDatas.get(to);
						Date[] aux = new Date[d.length + 1];
						for (int i = 0; i < d.length; i++) {
							aux[i] = d[i];
						}
						aux[d.length] = data;
						mapaMencoesRecebidasDatas.put(to, aux);
					}
				}	
			}
		}
	}
	
	/**
	 * Retorna o mapa das Mencoes recebidas pelo usuario autenticado com as datas
	 * @return
	 */
	public HashMap<String, Date[]> retornaMapaMencoesRecebidasComDatas(){
		return (HashMap<String, Date[]>) mapaMencoesRecebidasDatas;
	}
	
	/**
	 * Calcula o mapa das hashtag com datas
	 * @throws TwitterException
	 */
	public void calculaMapaHashTagComDatas() throws TwitterException{
		ResponseList<Status> a = getMentionsUser();
		for (Status status : a) {
			ArrayList<String> tags = capturaTags(status.getText());
			Date data = status.getCreatedAt();
			for (String string : tags) {
				adicionaAoMapaHashTagComDatas(string, data);
			}
		}
	}
	

	/**
	 * Mapeia o mapa das hashtag com datas
	 * @param string
	 * @param data
	 */
	private void adicionaAoMapaHashTagComDatas(String string, Date data) {
		if(!mapaTagDatas.containsKey(string)){
			Date[] d = new Date[1];
			d[0] = data;
			mapaTagDatas.put(string , d);
		}else{
			Date[] d = mapaTagDatas.get(string);
			Date[] aux = new Date[d.length + 1];
			for (int i = 0; i < d.length; i++) {
				aux[i] = d[i];
			}
			aux[d.length] = data;
			mapaTagDatas.put(string, aux);
		}
		
	}
	
	/**
	 * Retorna o mapa das hashTags com datas
	 * @return
	 */
	public HashMap<String, Date[]> retorneMapaHashTagComDatas(){
		return (HashMap<String, Date[]>) mapaTagDatas;
	}
	
	

	/**
	 * Exemplo de como usar as classes de autenticacao
	 * @param args
	 * @throws TwitterException 
	 * @throws IOException 
	 */
	public static void main(String[] args) throws TwitterException, IOException {
			InterfaceTwitter i = getInstance();
			i.setAuthConsumerTwitter();
			i.recuperaRequest();
			BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
			while (null == i.getAccessToken()) {
			      System.out.println("Open the following URL and grant access to your account:");
			      System.out.println(i.geraURL());
			      System.out.print("Enter the PIN(if aviailable) or just hit enter.[PIN]:");
			      String pin = br.readLine();
			      i.returnAccess(pin);
			}
			i.autentica();
			
			/*System.out.println("---------------------------------------------------------");
			
			getInformacoesUsuarioQualquer("savyoinobrega");
			System.out.println("---------------------------------------------------------");
			
			System.out.println("---------------------------------------------------");
			getInformacoesUsuario();
			System.out.println("-------------------------------------------------------");
		    
	        ResponseList<Status> testes = i.getTwitter().getMentions();
	        for(Status s : testes){
	        	System.out.println("id: " + s.getId());
	        	System.out.println("reply to screen name : "+ s.getInReplyToScreenName());
	        	System.out.println("texto: " + s.getText());
	        	System.out.println("tags: " + s.getHashtagEntities());
	        	System.out.println("usuario: " + s.getUser().getScreenName());
	        }

	        System.out.println("---------------------------------------------------");
	        
	        HashMap<String, Integer> m = i.retornaMapaMencoesRecebidas();
	        for (String s : m.keySet()) {
				System.out.println("Chave: " + s + "     Valor: " + m.get(s));
			}*/
	        
			System.out.println("Numero de followers: " + i.getFollowers().size());
			System.out.println("Numero de following: " + i.getFollowing().size());
	        System.out.println("---------------------------------------------------");
	        i.calculaMapaMencoesRecebidas();
			System.out.println("Mencoes recebidas: ");
			HashMap<String, Integer> m1 = i.retornaMapaMencoesRecebidas();
			for (String string : m1.keySet()) {
				System.out.println("Chave: " + string + "          Value: " + m1.get(string));
			}
	        
	        System.out.println("-------------------------------------------------------");
	        i.calculaMapaMencoesRecebidasComDatas();
	        HashMap<String, Date[]> d = i.retornaMapaMencoesRecebidasComDatas();
	        for (String string : d.keySet()) {
	        	System.out.println("Pessoa: " + string);
	        	System.out.println("Lista de Datas: [");
				for (Date s : d.get(string)) {
					System.out.print(s.toString() + ",");
				}
				System.out.println();
			}
	        
	       /* i.calculaMapaMencoesFeitasComData();
	        HashMap<String, Date[]> d = i.retornaMapaMencoesFeitasDatas();
	        for (String string : d.keySet()) {
	        	System.out.println("Pessoa: " + string);
	        	System.out.println("Lista de Datas: [");
				for (Date s : d.get(string)) {
					System.out.print(s.toString() + ",");
				}
				System.out.println();
			}
	        
	        
	        
			System.out.println("---------------------------------------------------");
			i.calculaMapaMencoesFeitas();
			System.out.println("Mencoes feitas: ");
			HashMap<String, Integer> m2 = i.retornaMapaMencoesFeitas();
			for (String string : m2.keySet()) {
				System.out.println("Chave: " + string + "          Value: " + m2.get(string));
			}*/
			
			System.out.println("----------------------------------------------------");
			i.calculaMapaHashTag();
			System.out.println("HashTags: ");
			HashMap<String, Integer> m3 = i.retorneMapaHashTag();
			for (String string : m3.keySet()) {
				System.out.println("Chave: " + string + "          Value: " + m3.get(string));
			}
			System.out.println("-----------------------------------------------------");
			i.calculaMapaHashTagComDatas();
	        HashMap<String, Date[]> de = i.retorneMapaHashTagComDatas();
	        for (String string : de.keySet()) {
	        	System.out.println("Pessoa: " + string);
	        	System.out.println("Lista de Datas: [");
				for (Date s : de.get(string)) {
					System.out.print(s.toString() + ",");
				}
				System.out.println();
			}
			
	        /*ResponseList<Status> timeline = twitter.getFriendsTimeline();
	        System.out.println("Exibindo a timeline");
	        System.out.println("----------------------------------------");
	        System.out.println(timeline.size());
	        for (Status s : timeline) {
	            System.out.println(s.getUser().getScreenName() + " - ");
	        }*/
			
			/*ResponseList<Status> test = i.getTwitter().getRetweetsOfMe();
			for (Status s : test) {
				System.out.println(s.getId());
				System.out.println(s.getRetweetCount());
				System.out.println(s.getInReplyToScreenName());
				System.out.println(s.getText());
				System.out.println(s.getHashtagEntities());
				System.out.println(s.getUser().getScreenName());
			}*/
			
			//i.getFollowing();
			/*System.out.println(i.getTwitter().getScreenName());
		    System.out.println(i.getTwitter().getRetweetedByMe().get(0));
		    System.out.println("Consegui terminar tudo!");
		    ArrayList<Object> lista = i.getInformacoesUsuario();
		    for (int j = 0; j < lista.size(); j++) {
				System.out.println(lista.get(j));
			}*/
		   
		    /*System.out.println("Imprimindo followers? ");
		    i.getFollowers();
		    for (long id : i.getTwitter().getFollowersIDs(0).getIDs())
		    	System.out.println("- " + id);
		    */
		    
		    /*PagableResponseList<User> timeline = (i.getTwitter()).getFriendsStatuses(-1);
	        System.out.println("Exibindo a timeline");
	        System.out.println("----------------------------------------");
	        System.out.println(timeline.size());
	        for (User s : timeline) {
	            System.out.println(s.getScreenName() + " - ");
	        }*/
			
			/*System.out.println("---------------------------------------------------");
			System.out.println("Mencoes recebidas: ");
			HashMap<String, Integer> m1 = i.retornaMapaMencoesRecebidas();
			for (String string : m1.keySet()) {
				System.out.println("Chave: " + string + "          Value: " + m1.get(string));
			}
			System.out.println("---------------------------------------------------");
			System.out.println("Mencoes feitas: ");
			HashMap<String, Integer> m2 = i.retornaMapaMencoesFeitas();
			for (String string : m2.keySet()) {
				System.out.println("Chave: " + string + "          Value: " + m2.get(string));
			}

	        System.out.println("---------------------------------------------------");
		    
	        ResponseList<Status> testes = i.getTwitter().getMentions();
	        for(Status s : testes){
	        	System.out.println("id: " + s.getId());
	        	System.out.println("reply to screen name : "+ s.getInReplyToScreenName());
	        	System.out.println("texto: " + s.getText());
	        	System.out.println("tags: " + s.getHashtagEntities());
	        	System.out.println("usuario: " + s.getUser().getScreenName());
	        }

	        System.out.println("---------------------------------------------------");
			
			ResponseList<Status> test = i.getTwitter().getRetweetsOfMe();
			for (Status s : test) {
				System.out.println(s.getId());
				System.out.println(s.getRetweetCount());
				System.out.println(s.getInReplyToScreenName());
				System.out.println(s.getText());
				System.out.println(s.getHashtagEntities());
				System.out.println(s.getUser().getScreenName());
			}*/

	}
}
